home *** CD-ROM | disk | FTP | other *** search
/ Ian & Stuart's Australian Mac 1993 September / September 93.iso / Archives / Applications / Graphics / image / Imagine / PDPConv.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-03-01  |  7.2 KB  |  290 lines  |  [TEXT/KAHL]
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <MacTypes.h>
  4. #include <Color.h>
  5. #include <FileMgr.h>
  6. #include <WindowMgr.h>
  7. #include <StdFilePkg.h>
  8.  
  9. Point    SFGwhere = { 90, 82 };
  10. Point    SFPwhere = { 106, 104 };
  11. SFReply    reply;
  12.   
  13. struct ImagineHeader
  14. {
  15.       char        Version[8];
  16.       long        OffsetToFirstSlice;
  17.       long        SliceBytes;
  18.       short        number_of_columns;
  19.       short        number_of_rows;
  20.       short        number_of_slices;
  21.       short        number_of_frames;
  22.       float        column_scale;
  23.       float        row_scale;
  24.       float        slice_scale;
  25.       float        frame_scale;
  26.       char        column_units[8];
  27.       char        row_units[8];
  28.       char        slice_units[8];
  29.       char        frame_units[8];
  30.       char        image_units[8];
  31.       Rect        Xsection;
  32. };
  33.  
  34. struct ImagineSliceHeader
  35. {
  36.     long        OffsetToFirstSlice;
  37.     float        SliceScale;
  38. };
  39.  
  40. Boolean GetImageParms(Header, offset, image_type, Uns, Multi)
  41.       struct        ImagineHeader*    Header;
  42.       long*                        offset;
  43.       short*                        image_type;
  44.       Boolean*                    Uns;
  45.       Boolean*                    Multi;
  46. {
  47.       short         nogood;
  48.       DialogPtr     DPtr;
  49.       short        items[3];
  50.       short         result;
  51.       short        itemhit;
  52.       short        soffset;
  53.       GrafPtr        saveport;
  54.       
  55.     nogood = true;
  56.     GetPort(&saveport);
  57.     DPtr = GetNewDialog(3796, 0L, -1L);
  58.     items[0] = 7;
  59.     items[1] = 8;
  60.     items[2] = 9;
  61.     Set_button(DPtr, 7, 1);
  62.     DrawDefault(DPtr, 1, 0L);
  63.     do
  64.       {
  65.         ModalDialog(0L, &itemhit);
  66.         switch (itemhit)
  67.          {
  68.           case 7:
  69.           case 8:
  70.           case 9:
  71.                   Do_radio_buttons(DPtr, 3, items, itemhit);
  72.                   break;
  73.           case 15:
  74.           case 10:
  75.                   Toggle_button(DPtr, itemhit);
  76.                   break;
  77.           case 2:
  78.                   DisposDialog(DPtr);
  79.                 SetPort(saveport);
  80.                   return(false);
  81.           case 1:
  82.                 if( DialogtoShort( DPtr, 3, &(*Header).number_of_rows, 0, 2048) &&
  83.                     DialogtoShort( DPtr, 4, &(*Header).number_of_columns, 0, 2048) &&
  84.                     DialogtoShort( DPtr, 5, &(*Header).number_of_slices, 0, 2048) &&
  85.                     DialogtoShort( DPtr, 6, &soffset, 0, 32000) )
  86.                     nogood = false;
  87.                   else SysBeep(1);
  88.                 break;
  89.          }
  90.       } while (nogood);
  91.   
  92.       *Uns = If_button(DPtr, 10);
  93.       *Multi = If_button(DPtr, 15);
  94.       if( If_button(DPtr, 7) ) *image_type = 0;
  95.       if( If_button(DPtr, 8) ) *image_type = 1;
  96.       if( If_button(DPtr, 9) ) *image_type = 2;
  97.       *offset = soffset;
  98.       DisposDialog(DPtr);
  99.       SetPort(saveport);
  100.       return(true);
  101. }
  102.     
  103.  
  104. main()
  105. {
  106.       short             *Data_out;
  107.       unsigned short     *Data_in;
  108.       unsigned char      *Data_in_char;
  109.       int                File_in;
  110.       int                File_out;
  111.       int                vRef;
  112.       int                refNum;
  113.       OSType            type;
  114.       Str255            fn;
  115.       short             col;
  116.       short             row;
  117.       long            i;
  118.       long            count_in;
  119.       long            count_out;
  120.       int             rsrc;
  121.       short            *scPtr;
  122.       Handle            scHandle;
  123.       short            slice;
  124.       short            image_type;
  125.       long            offset;
  126.       Boolean            Uns;
  127.       Boolean            Multi;
  128.       long            BOffset;
  129.       char            Blank[1024];
  130.       struct    ImagineHeader        Header;
  131.       struct    ImagineSliceHeader    SliceHeader;
  132.   
  133.     InitGraf(&thePort);
  134.     InitFonts();
  135.     FlushEvents( everyEvent, 0 );
  136.     InitWindows();
  137.     InitMenus();
  138.     InitDialogs(0L);
  139.     InitCursor();
  140.     
  141.     if( !GetImageParms(&Header, &offset, &image_type, &Uns, &Multi) ) return;
  142.     
  143.     fn[0] = 0;
  144.     if(!NewFile( &fn, &vRef )) return;
  145.     if(!CreateFile( &fn, &vRef, &File_out)) {SysBeep(1); return;}
  146.     SetVol( 0L, vRef );
  147.     
  148.     strcpy(Header.Version, "IMGN0001");
  149.     Header.OffsetToFirstSlice = 1024;
  150.       Header.SliceBytes = (long)Header.number_of_columns *
  151.                                 Header.number_of_rows * sizeof(short) +
  152.                                 sizeof(struct ImagineSliceHeader);
  153.       Header.number_of_frames = 1;
  154.       Header.column_scale = 2.16;
  155.       Header.row_scale = 2.16;
  156.       Header.slice_scale = 14.7;
  157.       Header.frame_scale = 1.0;
  158.       Header.column_units[0] = 0;
  159.       Header.row_units[0] = 0;
  160.       Header.slice_units[0] = 0;
  161.       Header.frame_units[0] = 0;
  162.       Header.image_units[0] = 0;
  163.       Header.Xsection.left =
  164.       Header.Xsection.right =
  165.       Header.Xsection.top =
  166.       Header.Xsection.bottom = 0;
  167.       
  168.     SliceHeader.OffsetToFirstSlice = sizeof(struct ImagineSliceHeader);
  169.     SliceHeader.SliceScale = 1.0;
  170.     
  171.     for( i = 0; i < 1024; i++ ) Blank[i] = 0;
  172.       count_out = 1024;
  173.       if( FSWrite(File_out, &count_out, &Blank) != noErr ) {SysBeep(1); return(1);}
  174.       if( SetFPos(File_out, fsFromStart, 0L) != noErr ) {SysBeep(1); return(1);}
  175.       count_out = sizeof(struct ImagineHeader);
  176.       if( FSWrite(File_out, &count_out, &Header) != noErr ) {SysBeep(1); return(1);}
  177.       if( SetFPos(File_out, fsFromStart, 1024) != noErr ) {SysBeep(1); return(1);}
  178.       
  179.     count_out = (long)Header.number_of_columns*
  180.                 (long)Header.number_of_rows;
  181.     if( image_type != 0 ) count_out *= 2L;
  182.     Data_in_char = (unsigned char*)(Data_in = (unsigned short*)NewPtr((Size)(count_out)));
  183.     Data_out  = (short*)NewPtr((Size)(count_out*2L));
  184.     if(Data_in == 0L || Data_out == 0L) {SysBeep(1); return;}
  185.     for( slice = 0; slice < Header.number_of_slices; slice++ )
  186.         {
  187.         if( Multi || (!Multi && slice == 0) )
  188.             {
  189.             fn[0] = 0;
  190.             while(!OldFile( &fn, &vRef, &type ));
  191.             if( FSOpen( &fn, vRef, &File_in ) != noErr) {SysBeep(1); return(1);}
  192.             if( SetFPos( File_in, fsFromStart, offset) != noErr ) {SysBeep(1); return(1);}
  193.             }
  194.         if( FSRead( File_in, &count_out, Data_in) != noErr ) {SysBeep(1); return(1);}
  195.         if( image_type != 0 ) count_out /= 2L;
  196.         if( Uns )
  197.             switch(image_type)
  198.                 {
  199.                 case    0:
  200.                     for( i = 0; i < count_out; i++ ) Data_out[i] = Data_in_char[i];
  201.                     break;
  202.                 case    1:
  203.                     for( i = 0; i < count_out; i++ ) Data_out[i] = Data_in[i]/2;
  204.                     break;
  205.                 case    2:
  206.                     for( i = 0; i < count_out; i++ )
  207.                         Data_out[i] = (((Data_in[i]>>8)&0x00FF)+((Data_in[i]<<8)&0xFF00))/2;
  208.                     break;
  209.                 }
  210.         else
  211.             switch(image_type)
  212.                 {
  213.                 case    0:
  214.                     for( i = 0; i < count_out; i++ ) Data_out[i] = ((char*)Data_in_char)[i];
  215.                     break;
  216.                 case    1:
  217.                     for( i = 0; i < count_out; i++ ) Data_out[i] = ((short*)Data_in)[i];
  218.                     break;
  219.                 case    2:
  220.                     for( i = 0; i < count_out; i++ )
  221.                         Data_out[i] = ((((short*)Data_in)[i]>>8)&0x00FF)+((((short*)Data_in)[i]<<8)&0xFF00);
  222.                     break;
  223.                 }
  224.                 
  225.           count_in = sizeof(struct ImagineSliceHeader);
  226.           if( FSWrite(File_out, &count_in, &SliceHeader) != noErr ) {SysBeep(1); return(1);}
  227.           
  228.         count_out *= 2L;
  229.         if( FSWrite(File_out, &count_out, Data_out) != noErr ) {SysBeep(1); return(1);}
  230.         if( Multi ) FSClose(File_in);
  231.         }
  232.     DisposPtr(Data_in);
  233.     DisposPtr(Data_out);
  234.     FSClose(File_out);
  235.     return(0);
  236. }
  237.  
  238. NewFile( fn, vRef )
  239. Str255    *fn;
  240. int        *vRef;
  241. {
  242.     SFPutFile(SFPwhere, "\pNew Image File", fn, 0L, &reply);
  243.     if (reply.good) {
  244.         pStrCopy(reply.fName, fn);
  245.         *vRef = reply.vRefNum;
  246.         return(1);
  247.     }
  248.     else return(0);
  249. }
  250.  
  251. OldFile( fn, vRef, type )
  252. Str255    *fn;
  253. int        *vRef;
  254. OSType    *type;
  255. {
  256.     SFTypeList    myTypes;
  257.     
  258.     myTypes[0]='BINA';
  259.     SFGetFile( SFGwhere, "\pOld Image File", 0L, 0, myTypes, 0L, &reply );
  260.     if (reply.good)
  261.      {
  262.         pStrCopy( reply.fName, fn );
  263.         *vRef = reply.vRefNum;
  264.         *type = reply.fType;
  265.         return(true);
  266.      }
  267.     else return(false);
  268. }
  269.  
  270. CreateFile( fn, vRef, theRef )
  271. Str255    *fn;
  272. int        *vRef;
  273. int        *theRef;
  274. {
  275.     int io;
  276.     
  277.     io=Create(fn, *vRef, 'IMGN', 'TEXT');
  278.     if ((io==noErr) || (io==dupFNErr)) io = FSOpen( fn, *vRef, theRef );
  279.     return( (io==noErr) || (io=dupFNErr) );
  280. }
  281.  
  282. pStrCopy( p1, p2 )
  283. register char *p1, *p2;
  284. {
  285.     register int len;
  286.     
  287.     len = *p2++ = *p1++;
  288.     while (--len>=0) *p2++=*p1++;
  289. }
  290.